<!DOCTYPE html>
<html>
<!-- Created by GNU Texinfo 7.1.1, https://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<!-- This file documents the use of the GNU compilers.

Copyright © 1988-2023 Free Software Foundation, Inc.

Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with the
Invariant Sections being "Funding Free Software", the Front-Cover
Texts being (a) (see below), and with the Back-Cover Texts being (b)
(see below).  A copy of the license is included in the section entitled
"GNU Free Documentation License".

(a) The FSF's Front-Cover Text is:

A GNU Manual

(b) The FSF's Back-Cover Text is:

You have freedom to copy and modify this GNU Manual, like GNU
     software.  Copies published by the Free Software Foundation raise
     funds for GNU development. -->
<title>SH Options (Using the GNU Compiler Collection (GCC))</title>

<meta name="description" content="SH Options (Using the GNU Compiler Collection (GCC))">
<meta name="keywords" content="SH Options (Using the GNU Compiler Collection (GCC))">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta name="viewport" content="width=device-width,initial-scale=1">

<link href="index.html" rel="start" title="Top">
<link href="Indices.html" rel="index" title="Indices">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Submodel-Options.html" rel="up" title="Submodel Options">
<link href="Solaris-2-Options.html" rel="next" title="Solaris 2 Options">
<link href="S_002f390-and-zSeries-Options.html" rel="prev" title="S/390 and zSeries Options">
<style type="text/css">
<!--
a.copiable-link {visibility: hidden; text-decoration: none; line-height: 0em}
kbd.key {font-style: normal}
span:hover a.copiable-link {visibility: visible}
-->
</style>


</head>

<body lang="en_US">
<div class="subsection-level-extent" id="SH-Options">
<div class="nav-panel">
<p>
Next: <a href="Solaris-2-Options.html" accesskey="n" rel="next">Solaris 2 Options</a>, Previous: <a href="S_002f390-and-zSeries-Options.html" accesskey="p" rel="prev">S/390 and zSeries Options</a>, Up: <a href="Submodel-Options.html" accesskey="u" rel="up">Machine-Dependent Options</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Indices.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<h4 class="subsection" id="SH-Options-1"><span>3.19.45 SH Options<a class="copiable-link" href="#SH-Options-1"> &para;</a></span></h4>

<p>These &lsquo;<samp class="samp">-m</samp>&rsquo; options are defined for the SH implementations:
</p>
<dl class="table">
<dt><a id="index-m1"></a><span><code class="code">-m1</code><a class="copiable-link" href="#index-m1"> &para;</a></span></dt>
<dd><p>Generate code for the SH1.
</p>
</dd>
<dt><a id="index-m2"></a><span><code class="code">-m2</code><a class="copiable-link" href="#index-m2"> &para;</a></span></dt>
<dd><p>Generate code for the SH2.
</p>
</dd>
<dt><code class="code">-m2e</code></dt>
<dd><p>Generate code for the SH2e.
</p>
</dd>
<dt><a id="index-m2a_002dnofpu"></a><span><code class="code">-m2a-nofpu</code><a class="copiable-link" href="#index-m2a_002dnofpu"> &para;</a></span></dt>
<dd><p>Generate code for the SH2a without FPU, or for a SH2a-FPU in such a way
that the floating-point unit is not used.
</p>
</dd>
<dt><a id="index-m2a_002dsingle_002donly"></a><span><code class="code">-m2a-single-only</code><a class="copiable-link" href="#index-m2a_002dsingle_002donly"> &para;</a></span></dt>
<dd><p>Generate code for the SH2a-FPU, in such a way that no double-precision
floating-point operations are used.
</p>
</dd>
<dt><a id="index-m2a_002dsingle"></a><span><code class="code">-m2a-single</code><a class="copiable-link" href="#index-m2a_002dsingle"> &para;</a></span></dt>
<dd><p>Generate code for the SH2a-FPU assuming the floating-point unit is in
single-precision mode by default.
</p>
</dd>
<dt><a id="index-m2a"></a><span><code class="code">-m2a</code><a class="copiable-link" href="#index-m2a"> &para;</a></span></dt>
<dd><p>Generate code for the SH2a-FPU assuming the floating-point unit is in
double-precision mode by default.
</p>
</dd>
<dt><a id="index-m3"></a><span><code class="code">-m3</code><a class="copiable-link" href="#index-m3"> &para;</a></span></dt>
<dd><p>Generate code for the SH3.
</p>
</dd>
<dt><a id="index-m3e"></a><span><code class="code">-m3e</code><a class="copiable-link" href="#index-m3e"> &para;</a></span></dt>
<dd><p>Generate code for the SH3e.
</p>
</dd>
<dt><a id="index-m4_002dnofpu"></a><span><code class="code">-m4-nofpu</code><a class="copiable-link" href="#index-m4_002dnofpu"> &para;</a></span></dt>
<dd><p>Generate code for the SH4 without a floating-point unit.
</p>
</dd>
<dt><a id="index-m4_002dsingle_002donly"></a><span><code class="code">-m4-single-only</code><a class="copiable-link" href="#index-m4_002dsingle_002donly"> &para;</a></span></dt>
<dd><p>Generate code for the SH4 with a floating-point unit that only
supports single-precision arithmetic.
</p>
</dd>
<dt><a id="index-m4_002dsingle"></a><span><code class="code">-m4-single</code><a class="copiable-link" href="#index-m4_002dsingle"> &para;</a></span></dt>
<dd><p>Generate code for the SH4 assuming the floating-point unit is in
single-precision mode by default.
</p>
</dd>
<dt><a id="index-m4"></a><span><code class="code">-m4</code><a class="copiable-link" href="#index-m4"> &para;</a></span></dt>
<dd><p>Generate code for the SH4.
</p>
</dd>
<dt><a id="index-m4_002d100"></a><span><code class="code">-m4-100</code><a class="copiable-link" href="#index-m4_002d100"> &para;</a></span></dt>
<dd><p>Generate code for SH4-100.
</p>
</dd>
<dt><a id="index-m4_002d100_002dnofpu"></a><span><code class="code">-m4-100-nofpu</code><a class="copiable-link" href="#index-m4_002d100_002dnofpu"> &para;</a></span></dt>
<dd><p>Generate code for SH4-100 in such a way that the
floating-point unit is not used.
</p>
</dd>
<dt><a id="index-m4_002d100_002dsingle"></a><span><code class="code">-m4-100-single</code><a class="copiable-link" href="#index-m4_002d100_002dsingle"> &para;</a></span></dt>
<dd><p>Generate code for SH4-100 assuming the floating-point unit is in
single-precision mode by default.
</p>
</dd>
<dt><a id="index-m4_002d100_002dsingle_002donly"></a><span><code class="code">-m4-100-single-only</code><a class="copiable-link" href="#index-m4_002d100_002dsingle_002donly"> &para;</a></span></dt>
<dd><p>Generate code for SH4-100 in such a way that no double-precision
floating-point operations are used.
</p>
</dd>
<dt><a id="index-m4_002d200"></a><span><code class="code">-m4-200</code><a class="copiable-link" href="#index-m4_002d200"> &para;</a></span></dt>
<dd><p>Generate code for SH4-200.
</p>
</dd>
<dt><a id="index-m4_002d200_002dnofpu"></a><span><code class="code">-m4-200-nofpu</code><a class="copiable-link" href="#index-m4_002d200_002dnofpu"> &para;</a></span></dt>
<dd><p>Generate code for SH4-200 without in such a way that the
floating-point unit is not used.
</p>
</dd>
<dt><a id="index-m4_002d200_002dsingle"></a><span><code class="code">-m4-200-single</code><a class="copiable-link" href="#index-m4_002d200_002dsingle"> &para;</a></span></dt>
<dd><p>Generate code for SH4-200 assuming the floating-point unit is in
single-precision mode by default.
</p>
</dd>
<dt><a id="index-m4_002d200_002dsingle_002donly"></a><span><code class="code">-m4-200-single-only</code><a class="copiable-link" href="#index-m4_002d200_002dsingle_002donly"> &para;</a></span></dt>
<dd><p>Generate code for SH4-200 in such a way that no double-precision
floating-point operations are used.
</p>
</dd>
<dt><a id="index-m4_002d300"></a><span><code class="code">-m4-300</code><a class="copiable-link" href="#index-m4_002d300"> &para;</a></span></dt>
<dd><p>Generate code for SH4-300.
</p>
</dd>
<dt><a id="index-m4_002d300_002dnofpu"></a><span><code class="code">-m4-300-nofpu</code><a class="copiable-link" href="#index-m4_002d300_002dnofpu"> &para;</a></span></dt>
<dd><p>Generate code for SH4-300 without in such a way that the
floating-point unit is not used.
</p>
</dd>
<dt><a id="index-m4_002d300_002dsingle"></a><span><code class="code">-m4-300-single</code><a class="copiable-link" href="#index-m4_002d300_002dsingle"> &para;</a></span></dt>
<dd><p>Generate code for SH4-300 in such a way that no double-precision
floating-point operations are used.
</p>
</dd>
<dt><a id="index-m4_002d300_002dsingle_002donly"></a><span><code class="code">-m4-300-single-only</code><a class="copiable-link" href="#index-m4_002d300_002dsingle_002donly"> &para;</a></span></dt>
<dd><p>Generate code for SH4-300 in such a way that no double-precision
floating-point operations are used.
</p>
</dd>
<dt><a id="index-m4_002d340"></a><span><code class="code">-m4-340</code><a class="copiable-link" href="#index-m4_002d340"> &para;</a></span></dt>
<dd><p>Generate code for SH4-340 (no MMU, no FPU).
</p>
</dd>
<dt><a id="index-m4_002d500"></a><span><code class="code">-m4-500</code><a class="copiable-link" href="#index-m4_002d500"> &para;</a></span></dt>
<dd><p>Generate code for SH4-500 (no FPU).  Passes <samp class="option">-isa=sh4-nofpu</samp> to the
assembler.
</p>
</dd>
<dt><a id="index-m4a_002dnofpu"></a><span><code class="code">-m4a-nofpu</code><a class="copiable-link" href="#index-m4a_002dnofpu"> &para;</a></span></dt>
<dd><p>Generate code for the SH4al-dsp, or for a SH4a in such a way that the
floating-point unit is not used.
</p>
</dd>
<dt><a id="index-m4a_002dsingle_002donly"></a><span><code class="code">-m4a-single-only</code><a class="copiable-link" href="#index-m4a_002dsingle_002donly"> &para;</a></span></dt>
<dd><p>Generate code for the SH4a, in such a way that no double-precision
floating-point operations are used.
</p>
</dd>
<dt><a id="index-m4a_002dsingle"></a><span><code class="code">-m4a-single</code><a class="copiable-link" href="#index-m4a_002dsingle"> &para;</a></span></dt>
<dd><p>Generate code for the SH4a assuming the floating-point unit is in
single-precision mode by default.
</p>
</dd>
<dt><a id="index-m4a"></a><span><code class="code">-m4a</code><a class="copiable-link" href="#index-m4a"> &para;</a></span></dt>
<dd><p>Generate code for the SH4a.
</p>
</dd>
<dt><a id="index-m4al"></a><span><code class="code">-m4al</code><a class="copiable-link" href="#index-m4al"> &para;</a></span></dt>
<dd><p>Same as <samp class="option">-m4a-nofpu</samp>, except that it implicitly passes
<samp class="option">-dsp</samp> to the assembler.  GCC doesn&rsquo;t generate any DSP
instructions at the moment.
</p>
</dd>
<dt><a id="index-mb"></a><span><code class="code">-mb</code><a class="copiable-link" href="#index-mb"> &para;</a></span></dt>
<dd><p>Compile code for the processor in big-endian mode.
</p>
</dd>
<dt><a id="index-ml"></a><span><code class="code">-ml</code><a class="copiable-link" href="#index-ml"> &para;</a></span></dt>
<dd><p>Compile code for the processor in little-endian mode.
</p>
</dd>
<dt><a id="index-mdalign"></a><span><code class="code">-mdalign</code><a class="copiable-link" href="#index-mdalign"> &para;</a></span></dt>
<dd><p>Align doubles at 64-bit boundaries.  Note that this changes the calling
conventions, and thus some functions from the standard C library do
not work unless you recompile it first with <samp class="option">-mdalign</samp>.
</p>
</dd>
<dt><a id="index-mrelax-7"></a><span><code class="code">-mrelax</code><a class="copiable-link" href="#index-mrelax-7"> &para;</a></span></dt>
<dd><p>Shorten some address references at link time, when possible; uses the
linker option <samp class="option">-relax</samp>.
</p>
</dd>
<dt><a id="index-mbigtable"></a><span><code class="code">-mbigtable</code><a class="copiable-link" href="#index-mbigtable"> &para;</a></span></dt>
<dd><p>Use 32-bit offsets in <code class="code">switch</code> tables.  The default is to use
16-bit offsets.
</p>
</dd>
<dt><a id="index-mbitops"></a><span><code class="code">-mbitops</code><a class="copiable-link" href="#index-mbitops"> &para;</a></span></dt>
<dd><p>Enable the use of bit manipulation instructions on SH2A.
</p>
</dd>
<dt><a id="index-mfmovd"></a><span><code class="code">-mfmovd</code><a class="copiable-link" href="#index-mfmovd"> &para;</a></span></dt>
<dd><p>Enable the use of the instruction <code class="code">fmovd</code>.  Check <samp class="option">-mdalign</samp> for
alignment constraints.
</p>
</dd>
<dt><a id="index-mrenesas"></a><span><code class="code">-mrenesas</code><a class="copiable-link" href="#index-mrenesas"> &para;</a></span></dt>
<dd><p>Comply with the calling conventions defined by Renesas.
</p>
</dd>
<dt><a id="index-mno_002drenesas"></a><span><code class="code">-mno-renesas</code><a class="copiable-link" href="#index-mno_002drenesas"> &para;</a></span></dt>
<dd><p>Comply with the calling conventions defined for GCC before the Renesas
conventions were available.  This option is the default for all
targets of the SH toolchain.
</p>
</dd>
<dt><a id="index-mnomacsave"></a><span><code class="code">-mnomacsave</code><a class="copiable-link" href="#index-mnomacsave"> &para;</a></span></dt>
<dd><p>Mark the <code class="code">MAC</code> register as call-clobbered, even if
<samp class="option">-mrenesas</samp> is given.
</p>
</dd>
<dt><a class="index-entry-id" id="index-mno_002dieee"></a>
<a id="index-mieee-1"></a><span><code class="code">-mieee</code><a class="copiable-link" href="#index-mieee-1"> &para;</a></span></dt>
<dt><code class="code">-mno-ieee</code></dt>
<dd><p>Control the IEEE compliance of floating-point comparisons, which affects the
handling of cases where the result of a comparison is unordered.  By default
<samp class="option">-mieee</samp> is implicitly enabled.  If <samp class="option">-ffinite-math-only</samp> is
enabled <samp class="option">-mno-ieee</samp> is implicitly set, which results in faster
floating-point greater-equal and less-equal comparisons.  The implicit settings
can be overridden by specifying either <samp class="option">-mieee</samp> or <samp class="option">-mno-ieee</samp>.
</p>
</dd>
<dt><a id="index-minline_002dic_005finvalidate"></a><span><code class="code">-minline-ic_invalidate</code><a class="copiable-link" href="#index-minline_002dic_005finvalidate"> &para;</a></span></dt>
<dd><p>Inline code to invalidate instruction cache entries after setting up
nested function trampolines.
This option has no effect if <samp class="option">-musermode</samp> is in effect and the selected
code generation option (e.g. <samp class="option">-m4</samp>) does not allow the use of the <code class="code">icbi</code>
instruction.
If the selected code generation option does not allow the use of the <code class="code">icbi</code>
instruction, and <samp class="option">-musermode</samp> is not in effect, the inlined code
manipulates the instruction cache address array directly with an associative
write.  This not only requires privileged mode at run time, but it also
fails if the cache line had been mapped via the TLB and has become unmapped.
</p>
</dd>
<dt><a id="index-misize-1"></a><span><code class="code">-misize</code><a class="copiable-link" href="#index-misize-1"> &para;</a></span></dt>
<dd><p>Dump instruction size and location in the assembly code.
</p>
</dd>
<dt><a id="index-mpadstruct"></a><span><code class="code">-mpadstruct</code><a class="copiable-link" href="#index-mpadstruct"> &para;</a></span></dt>
<dd><p>This option is deprecated.  It pads structures to multiple of 4 bytes,
which is incompatible with the SH ABI.
</p>
</dd>
<dt><a id="index-matomic_002dmodel_003dmodel"></a><span><code class="code">-matomic-model=<var class="var">model</var></code><a class="copiable-link" href="#index-matomic_002dmodel_003dmodel"> &para;</a></span></dt>
<dd><p>Sets the model of atomic operations and additional parameters as a comma
separated list.  For details on the atomic built-in functions see
<a class="ref" href="_005f_005fatomic-Builtins.html">Built-in Functions for Memory Model Aware Atomic Operations</a>.  The following models and parameters are supported:
</p>
<dl class="table">
<dt>&lsquo;<samp class="samp">none</samp>&rsquo;</dt>
<dd><p>Disable compiler generated atomic sequences and emit library calls for atomic
operations.  This is the default if the target is not <code class="code">sh*-*-linux*</code>.
</p>
</dd>
<dt>&lsquo;<samp class="samp">soft-gusa</samp>&rsquo;</dt>
<dd><p>Generate GNU/Linux compatible gUSA software atomic sequences for the atomic
built-in functions.  The generated atomic sequences require additional support
from the interrupt/exception handling code of the system and are only suitable
for SH3* and SH4* single-core systems.  This option is enabled by default when
the target is <code class="code">sh*-*-linux*</code> and SH3* or SH4*.  When the target is SH4A,
this option also partially utilizes the hardware atomic instructions
<code class="code">movli.l</code> and <code class="code">movco.l</code> to create more efficient code, unless
&lsquo;<samp class="samp">strict</samp>&rsquo; is specified.  
</p>
</dd>
<dt>&lsquo;<samp class="samp">soft-tcb</samp>&rsquo;</dt>
<dd><p>Generate software atomic sequences that use a variable in the thread control
block.  This is a variation of the gUSA sequences which can also be used on
SH1* and SH2* targets.  The generated atomic sequences require additional
support from the interrupt/exception handling code of the system and are only
suitable for single-core systems.  When using this model, the &lsquo;<samp class="samp">gbr-offset=</samp>&rsquo;
parameter has to be specified as well.
</p>
</dd>
<dt>&lsquo;<samp class="samp">soft-imask</samp>&rsquo;</dt>
<dd><p>Generate software atomic sequences that temporarily disable interrupts by
setting <code class="code">SR.IMASK = 1111</code>.  This model works only when the program runs
in privileged mode and is only suitable for single-core systems.  Additional
support from the interrupt/exception handling code of the system is not
required.  This model is enabled by default when the target is
<code class="code">sh*-*-linux*</code> and SH1* or SH2*.
</p>
</dd>
<dt>&lsquo;<samp class="samp">hard-llcs</samp>&rsquo;</dt>
<dd><p>Generate hardware atomic sequences using the <code class="code">movli.l</code> and <code class="code">movco.l</code>
instructions only.  This is only available on SH4A and is suitable for
multi-core systems.  Since the hardware instructions support only 32 bit atomic
variables access to 8 or 16 bit variables is emulated with 32 bit accesses.
Code compiled with this option is also compatible with other software
atomic model interrupt/exception handling systems if executed on an SH4A
system.  Additional support from the interrupt/exception handling code of the
system is not required for this model.
</p>
</dd>
<dt>&lsquo;<samp class="samp">gbr-offset=</samp>&rsquo;</dt>
<dd><p>This parameter specifies the offset in bytes of the variable in the thread
control block structure that should be used by the generated atomic sequences
when the &lsquo;<samp class="samp">soft-tcb</samp>&rsquo; model has been selected.  For other models this
parameter is ignored.  The specified value must be an integer multiple of four
and in the range 0-1020.
</p>
</dd>
<dt>&lsquo;<samp class="samp">strict</samp>&rsquo;</dt>
<dd><p>This parameter prevents mixed usage of multiple atomic models, even if they
are compatible, and makes the compiler generate atomic sequences of the
specified model only.
</p>
</dd>
</dl>

</dd>
<dt><a id="index-mtas"></a><span><code class="code">-mtas</code><a class="copiable-link" href="#index-mtas"> &para;</a></span></dt>
<dd><p>Generate the <code class="code">tas.b</code> opcode for <code class="code">__atomic_test_and_set</code>.
Notice that depending on the particular hardware and software configuration
this can degrade overall performance due to the operand cache line flushes
that are implied by the <code class="code">tas.b</code> instruction.  On multi-core SH4A
processors the <code class="code">tas.b</code> instruction must be used with caution since it
can result in data corruption for certain cache configurations.
</p>
</dd>
<dt><a id="index-mprefergot"></a><span><code class="code">-mprefergot</code><a class="copiable-link" href="#index-mprefergot"> &para;</a></span></dt>
<dd><p>When generating position-independent code, emit function calls using
the Global Offset Table instead of the Procedure Linkage Table.
</p>
</dd>
<dt><a class="index-entry-id" id="index-mno_002dusermode"></a>
<a id="index-musermode"></a><span><code class="code">-musermode</code><a class="copiable-link" href="#index-musermode"> &para;</a></span></dt>
<dt><code class="code">-mno-usermode</code></dt>
<dd><p>Don&rsquo;t allow (allow) the compiler generating privileged mode code.  Specifying
<samp class="option">-musermode</samp> also implies <samp class="option">-mno-inline-ic_invalidate</samp> if the
inlined code would not work in user mode.  <samp class="option">-musermode</samp> is the default
when the target is <code class="code">sh*-*-linux*</code>.  If the target is SH1* or SH2*
<samp class="option">-musermode</samp> has no effect, since there is no user mode.
</p>
</dd>
<dt><a id="index-multcost_003dnumber"></a><span><code class="code">-multcost=<var class="var">number</var></code><a class="copiable-link" href="#index-multcost_003dnumber"> &para;</a></span></dt>
<dd><p>Set the cost to assume for a multiply insn.
</p>
</dd>
<dt><a id="index-mdiv_003dstrategy"></a><span><code class="code">-mdiv=<var class="var">strategy</var></code><a class="copiable-link" href="#index-mdiv_003dstrategy"> &para;</a></span></dt>
<dd><p>Set the division strategy to be used for integer division operations.
<var class="var">strategy</var> can be one of: 
</p>
<dl class="table">
<dt>&lsquo;<samp class="samp">call-div1</samp>&rsquo;</dt>
<dd><p>Calls a library function that uses the single-step division instruction
<code class="code">div1</code> to perform the operation.  Division by zero calculates an
unspecified result and does not trap.  This is the default except for SH4,
SH2A and SHcompact.
</p>
</dd>
<dt>&lsquo;<samp class="samp">call-fp</samp>&rsquo;</dt>
<dd><p>Calls a library function that performs the operation in double precision
floating point.  Division by zero causes a floating-point exception.  This is
the default for SHcompact with FPU.  Specifying this for targets that do not
have a double precision FPU defaults to <code class="code">call-div1</code>.
</p>
</dd>
<dt>&lsquo;<samp class="samp">call-table</samp>&rsquo;</dt>
<dd><p>Calls a library function that uses a lookup table for small divisors and
the <code class="code">div1</code> instruction with case distinction for larger divisors.  Division
by zero calculates an unspecified result and does not trap.  This is the default
for SH4.  Specifying this for targets that do not have dynamic shift
instructions defaults to <code class="code">call-div1</code>.
</p>
</dd>
</dl>

<p>When a division strategy has not been specified the default strategy is
selected based on the current target.  For SH2A the default strategy is to
use the <code class="code">divs</code> and <code class="code">divu</code> instructions instead of library function
calls.
</p>
</dd>
<dt><a id="index-maccumulate_002doutgoing_002dargs"></a><span><code class="code">-maccumulate-outgoing-args</code><a class="copiable-link" href="#index-maccumulate_002doutgoing_002dargs"> &para;</a></span></dt>
<dd><p>Reserve space once for outgoing arguments in the function prologue rather
than around each call.  Generally beneficial for performance and size.  Also
needed for unwinding to avoid changing the stack frame around conditional code.
</p>
</dd>
<dt><a id="index-mdivsi3_005flibfunc_003dname"></a><span><code class="code">-mdivsi3_libfunc=<var class="var">name</var></code><a class="copiable-link" href="#index-mdivsi3_005flibfunc_003dname"> &para;</a></span></dt>
<dd><p>Set the name of the library function used for 32-bit signed division to
<var class="var">name</var>.
This only affects the name used in the &lsquo;<samp class="samp">call</samp>&rsquo; division strategies, and
the compiler still expects the same sets of input/output/clobbered registers as
if this option were not present.
</p>
</dd>
<dt><a id="index-mfixed_002drange-2"></a><span><code class="code">-mfixed-range=<var class="var">register-range</var></code><a class="copiable-link" href="#index-mfixed_002drange-2"> &para;</a></span></dt>
<dd><p>Generate code treating the given register range as fixed registers.
A fixed register is one that the register allocator cannot use.  This is
useful when compiling kernel code.  A register range is specified as
two registers separated by a dash.  Multiple register ranges can be
specified separated by a comma.
</p>
</dd>
<dt><a id="index-mbranch_002dcost_003dnum"></a><span><code class="code">-mbranch-cost=<var class="var">num</var></code><a class="copiable-link" href="#index-mbranch_002dcost_003dnum"> &para;</a></span></dt>
<dd><p>Assume <var class="var">num</var> to be the cost for a branch instruction.  Higher numbers
make the compiler try to generate more branch-free code if possible.  
If not specified the value is selected depending on the processor type that
is being compiled for.
</p>
</dd>
<dt><a class="index-entry-id" id="index-mno_002dzdcbranch"></a>
<a id="index-mzdcbranch"></a><span><code class="code">-mzdcbranch</code><a class="copiable-link" href="#index-mzdcbranch"> &para;</a></span></dt>
<dt><code class="code">-mno-zdcbranch</code></dt>
<dd><p>Assume (do not assume) that zero displacement conditional branch instructions
<code class="code">bt</code> and <code class="code">bf</code> are fast.  If <samp class="option">-mzdcbranch</samp> is specified, the
compiler prefers zero displacement branch code sequences.  This is
enabled by default when generating code for SH4 and SH4A.  It can be explicitly
disabled by specifying <samp class="option">-mno-zdcbranch</samp>.
</p>
</dd>
<dt><a id="index-mcbranch_002dforce_002ddelay_002dslot"></a><span><code class="code">-mcbranch-force-delay-slot</code><a class="copiable-link" href="#index-mcbranch_002dforce_002ddelay_002dslot"> &para;</a></span></dt>
<dd><p>Force the usage of delay slots for conditional branches, which stuffs the delay
slot with a <code class="code">nop</code> if a suitable instruction cannot be found.  By default
this option is disabled.  It can be enabled to work around hardware bugs as
found in the original SH7055.
</p>
</dd>
<dt><a class="index-entry-id" id="index-mno_002dfused_002dmadd-4"></a>
<a id="index-mfused_002dmadd-4"></a><span><code class="code">-mfused-madd</code><a class="copiable-link" href="#index-mfused_002dmadd-4"> &para;</a></span></dt>
<dt><code class="code">-mno-fused-madd</code></dt>
<dd><p>Generate code that uses (does not use) the floating-point multiply and
accumulate instructions.  These instructions are generated by default
if hardware floating point is used.  The machine-dependent
<samp class="option">-mfused-madd</samp> option is now mapped to the machine-independent
<samp class="option">-ffp-contract=fast</samp> option, and <samp class="option">-mno-fused-madd</samp> is
mapped to <samp class="option">-ffp-contract=off</samp>.
</p>
</dd>
<dt><a class="index-entry-id" id="index-mno_002dfsca"></a>
<a id="index-mfsca"></a><span><code class="code">-mfsca</code><a class="copiable-link" href="#index-mfsca"> &para;</a></span></dt>
<dt><code class="code">-mno-fsca</code></dt>
<dd><p>Allow or disallow the compiler to emit the <code class="code">fsca</code> instruction for sine
and cosine approximations.  The option <samp class="option">-mfsca</samp> must be used in
combination with <samp class="option">-funsafe-math-optimizations</samp>.  It is enabled by default
when generating code for SH4A.  Using <samp class="option">-mno-fsca</samp> disables sine and cosine
approximations even if <samp class="option">-funsafe-math-optimizations</samp> is in effect.
</p>
</dd>
<dt><a class="index-entry-id" id="index-mno_002dfsrra"></a>
<a id="index-mfsrra"></a><span><code class="code">-mfsrra</code><a class="copiable-link" href="#index-mfsrra"> &para;</a></span></dt>
<dt><code class="code">-mno-fsrra</code></dt>
<dd><p>Allow or disallow the compiler to emit the <code class="code">fsrra</code> instruction for
reciprocal square root approximations.  The option <samp class="option">-mfsrra</samp> must be used
in combination with <samp class="option">-funsafe-math-optimizations</samp> and
<samp class="option">-ffinite-math-only</samp>.  It is enabled by default when generating code for
SH4A.  Using <samp class="option">-mno-fsrra</samp> disables reciprocal square root approximations
even if <samp class="option">-funsafe-math-optimizations</samp> and <samp class="option">-ffinite-math-only</samp> are
in effect.
</p>
</dd>
<dt><a id="index-mpretend_002dcmove"></a><span><code class="code">-mpretend-cmove</code><a class="copiable-link" href="#index-mpretend_002dcmove"> &para;</a></span></dt>
<dd><p>Prefer zero-displacement conditional branches for conditional move instruction
patterns.  This can result in faster code on the SH4 processor.
</p>
</dd>
<dt><a id="index-fdpic"></a><span><code class="code">-mfdpic</code><a class="copiable-link" href="#index-fdpic"> &para;</a></span></dt>
<dd><p>Generate code using the FDPIC ABI.
</p>
</dd>
</dl>

</div>
<hr>
<div class="nav-panel">
<p>
Next: <a href="Solaris-2-Options.html">Solaris 2 Options</a>, Previous: <a href="S_002f390-and-zSeries-Options.html">S/390 and zSeries Options</a>, Up: <a href="Submodel-Options.html">Machine-Dependent Options</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Indices.html" title="Index" rel="index">Index</a>]</p>
</div>



</body>
</html>
